\subsection{Ejercicio 1}
	Este primer ejercicio del trabajo práctico consistió en crear una tabla de descriptores globales (\code{GDT}) básica, para luego pasar el 
procesador a modo protegido y escribir en la memoria de vídeo y pintar las lineas azules.

 	Para esto se utulizo el archivo \code{gdt.c} dado por la catedra con la estructura de la \code{GDT\_ENTRY}, y se definieron los segmentos en el archivo \code{gdt.c}.

\subsubsection{\code{gdt.c}}
	El archivo consiste en un array de estructuras \code{gdt\_entry} definidas en \code{gdt.h}. La estructura describe un descriptor global 
que mide 8 \keyword{bytes}.
	Se compone de bits reservados para el tamaño (\code{limit}), la dirección base del segmento a describir (\code{base}), y diversos atributos 
que serán explicados a continuación junto con los segmentos que definimos:

\noindent La \code{gdt} define cuatro descriptores en el siguiente orden:
\begin{itemize}
	\item Descriptor nulo
	\item Descriptor para el segmento de código de kernel
	\item Descriptor para el segmento de datos de kernel
	\item Descriptor para el segmento que apunta a la memoria de video.
	\item Descriptor para el segmento de código de usuario
	\item Descriptor para el segmento de datos de usuario
\end{itemize}

\begin{center}
\includegraphics[scale=0.3]{gdt_descriptor.png}
\end{center}

\noindent \textbf{Campos de cada descriptor}:
\begin{itemize}
	\item\code{Limit}: Indica el tamaño de cada segmento definido. En las entradas de código y datos estos \keyword{bits} están seteados a su máximo valor, 
que junto con la base y el \keyword{bit} de \keyword{granularity} van a formar dos segmentos de 4gb cada uno. En el segmento de video el tamaño es de 4kb, 
o sea, una página.
	\item\code{Base}: Indica en que posición de memoria empiezan los segmentos. Tanto el segmento de código como el de datos tienen como base al 
\code{0x0000}, para poder lograr el tamaño final de 4gb. El segmento de vídeo empieza en \code{0x0B8000} según la especificación dada.
	\item\code{Type}: Este campo de 4 \keyword{bits}, indica si el segmento es de código o de datos y los permisos de lectura, escritura y ejecución 
entre otras cosas. Se decidió que el segmento de código lleve el valor \code{0xA} (según el manual de Intel, esto es segmento de código de lectura/escritura), 
el segmento de datos \code{0x2} (segmento de datos de lectura/escritura) y el segmento de video también \code{0x2}.
	\item\code{Bit S}: Indica si el segmento es de código/datos o de sistema. Para todos los segmentos se indica que es un segmento de código/datos.
	\item\code{Bit DPL}: Indica el nivel de privilegio que tiene el segmento. Todos los segmentos tienen privilegio a nivel \keyword{Kernel} (el máximo posible).
	\item\code{Bit P}: Indica si el segmento está presente. Para todos los segmentos, se indica que esta presente, sino al tratar de accederlo se 
produciría una excepción.
	\item\code{Bit AVL}: Irrelevante, seteado a 0.
	\item\code{Bit L}: Este \keyword{bit} indica si el segmento contiene código de 64 \keyword{bits}. Seteado a 0 para indicar que este no es el caso.
	\item\code{Bit D/B}: El \keyword{bit} funciona de manera diferente según se trate de un segmento de código, datos expand-down, o de stack. 
Lo único relevante en este punto es que en el segmento de código está seteado en 1 para que interprete direcciones de 32 \keyword{bits} y operandos de 32 u 8 \keyword{bits}, como es necesario en modo protegido.
	\item\code{Bit G}: Este \keyword{bit} (\code{granularity}) indica si el campo \code{limit} del segmento se interpreta como unidad de \keyword{bytes} (dando como máximo 1MB de tamaño de segmento) o como unidades de 4kb (dando el máximo de 4gb buscado). Para todos los segmentos, este \keyword{bit} esta seteado.
\end{itemize}

\subsubsection{\code{kernel.asm}}
	Luego de habilitar la A20 y detener las interrupciones, se carga el registro \code{GDTR} que apunta a la tabla de descriptores que fue explicada 
anteriormente. Para ello se utilizó la instrucción:

\vspace{2mm}
	\code{lgdt [GDT\_DESC]}
\vspace{2mm}

	A continuación se setea el \keyword{bit} 0 del registro de control \code{cr0}, poniendo el procesador en modo protegido, y se realiza un \code{jump far} 
al comienzo del código en modo protegido:

\begin{verbatim}
	mov eax, cr0
	or eax, 1
	mov cr0, eax
	jmp 0x08:modo_protegido
\end{verbatim}

\vspace{2mm}

	El \code{0x08} le indica al registro de segmento \code{CS} que apunte a esa dirección desde la dirección que apunta el \code{GDTR}. Que es donde 
está el descriptor de segmento de código de kernel que definimos antes. Luego se acomodan los demás registros de segmento al segmento de datos y se empieza con 
el código para escribir en pantalla.

	Para escribir en la pantalla se va a usar la instrucción \code{stosw}. La instrucción escribe un \keyword{word} guardado en \code{ax} en la 
dirección apuntada por \code{es:edi}. Entonces se carga el inicio del segmento de vídeo en el registro \code{es}, después se limpia la pantalla 
escribiendo \code{0x0000} en \code{ax} e incrementando el \keyword{offset} de \code{edi}. El registro \code{ecx} se utiliza para manejar el \keyword{loop}.

\begin{verbatim}
	mov ax, 0x18
	mov es, ax
	xor edi,edi
	mov ecx, (25 * 80) //2000
	xor eax,eax
	clean:
		stosw	
		loop clean
\end{verbatim}


	La instruccion stosw, escribe un word en es:edi, que es donde esta la memoria de video, luego seguimos el ciclo para llenar toda la pantalla. Posteriormente se realizan las rutinas simples para dibujar el marco de una manera similar a la recientemente mostrada.

\subsection{Preguntas}
\begin{itemize}
	\item Pregunta 1: ¿Qué ocurre si se intenta escribir en la fila 26, columna 1 de la matriz de video?¿Por qué?
\end{itemize}
La dimensión de la matriz de video es de 25 filas por 80 columnas. Es decir, 2000 caracteres.
Por cada carácter, necesita 2bytes de espacio en memoria (1byte para el caracter y 1byte para los atributos). Ésto da un total de 4000bytes (0x0FA0 bytes) para mapear la matriz de video en memoria.
El segmento de video (direccionable) tiene base en la dirección física 0xB80000, pero como además tiene un tamaño de 0x0FA0 bytes, la última dirección que pertenezca al segmento será la 0x0F9F. Y corresponde al byte que contiene el carácter, de la posición 25(fila), 80(columna).

Si se intenta escribir en la fila 26, columna 1 de la matriz de video, se estará tratando de escribir en la posición de memoria 0xB8000+0x0FA0, que no pertenece al segmento de video (como se observa en la siguiente imagen) y causará fallo de segmentación.

\indent  \indent  \indent \includegraphics[scale=0.3]{pregunta1.png} \\
\indent Comienza en la posición 0xB8000 en el primer casillero y crece de izquierda a derecha, y de arriba a abajo. Cada casillero representa 2bytes de memoria.
El casillero pintado de color verde oscuro son los dos últimos bytes direccionables del segmento de video (y se corresponde con el carácter de la posición 25,80 en pantalla). El de color rojo, es el primero que no pertenece al segmento; y se encuentra en la posición de memoria 0xB8000+0x0FA0


Aclaración: las filas están numeradas de 0 a 24 y las columnas de 0 a 79. Cuando hacemos referencia al carácter de la fila 25, columna 0, hablamos de que está en la vigésimosexta fila , primera columna.
